import 'dart:io';
import 'dart:typed_data';
import 'package:get/get.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:signature/signature.dart';
import 'package:flutter_easyloading/flutter_easyloading.dart';
import 'package:path_provider/path_provider.dart';
import 'package:permission_handler/permission_handler.dart';
import '../../../common/api/index.dart';
import '../../../common/models/index.dart';
import '../../../common/mixins/user_profile_mixin.dart';
import '../../../common/utils/index.dart';
import '../../../common/services/dio_service.dart';
import 'theme.dart';

class YanshouAssessmentDetialController extends GetxController with UserProfileMixin {
  YanshouAssessmentDetialController();

  // 🔥 状态管理
  final isLoading = true.obs;
  final errorMessage = ''.obs;
  final Rx<ProjectModel?> project = Rx<ProjectModel?>(null);
  
  // 👥 专家列表状态管理
  final isLoadingExperts = false.obs;
  final expertErrorMessage = ''.obs;
  final RxList<ProjectExpert> projectExperts = <ProjectExpert>[].obs;
  
  // 📝 验收相关状态管理
  final checkOpinion = ''.obs;             // 验收意见
  final isUploading = false.obs;           // 正在上传状态
  final uploadErrorMessage = ''.obs;       // 上传错误信息
  final hasSignature = false.obs;          // 是否已有签名
  final signatureUploaded = false.obs;     // 签名是否已上传成功
  final isLeader = false.obs;              // 是否是组长
  final isCheckingLastExpert = false.obs;  // 是否正在检查最后专家
  
  // 📁 验收归档文件列表状态管理
  final isLoadingFiles = false.obs;
  final filesErrorMessage = ''.obs;
  final RxList<SupplierFileModel> acceptanceFiles = <SupplierFileModel>[].obs;
  
  // 📥 文件下载状态管理
  final RxMap<int, double> downloadProgress = <int, double>{}.obs; // 文件ID -> 下载进度(0-1)
  final RxMap<int, bool> isDownloading = <int, bool>{}.obs; // 文件ID -> 是否正在下载
  
  // 🖊️ 手写签名控制器
  late SignatureController signatureController;
  
  // 项目ID
  int? projectId;

  _initData() {
    _initializeParameters();
    _initializeData(); // 在参数初始化后再初始化数据
    _initializeSignature(); // 初始化签名控制器
    update(["yanshou_assessment_detial"]);
  }

  /// 初始化签名控制器
  void _initializeSignature() {
    signatureController = SignatureController(
      penStrokeWidth: 2,
      penColor: Colors.black,
      exportBackgroundColor: Colors.white,
    );
    
    // 监听签名变化
    signatureController.addListener(() {
      hasSignature.value = signatureController.isNotEmpty;
    });
  }

  /// 统一的参数初始化方法
  void _initializeParameters() {
    try {
      final args = Get.arguments;
      
      if (args != null && args is Map<String, dynamic>) {
        projectId = args['projectId'] is int ? args['projectId'] as int : 
                   int.tryParse(args['projectId']?.toString() ?? '0');
        
        debugPrint('📋 验收评估详情页 - 参数初始化成功: projectId=$projectId');
      } else {
        _setDefaultParameters();
      }
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 参数初始化失败: $e');
      _setDefaultParameters();
    }
  }

  /// 设置默认参数
  void _setDefaultParameters() {
    projectId = null;
    debugPrint('⚠️ 验收评估详情页 - 使用默认参数');
  }

  /// 在参数初始化后进行数据初始化
  void _initializeData() {
    if (projectId != null && projectId! > 0) {
      loadProjectDetail();
      loadProjectExperts();
      loadAcceptanceFiles(); // 加载验收归档文件
      _loadLeaderInfo(); // 加载验收组长信息
    } else {
      errorMessage.value = projectId == null ? '未找到项目ID' : '项目ID无效';
      isLoading.value = false;
      debugPrint('❌ 验收评估详情页 - 项目ID无效，无法加载数据');
    }
  }
  
  /// 加载验收组长信息
  Future<void> _loadLeaderInfo() async {
    if (projectId == null) return;
    
    try {
      debugPrint('👑 验收评估详情页 - 开始加载验收组长信息');
      
      final leaderId = await UserApi.getMostVotesExpertId(
        projectId: projectId!,
        voteFlag: 1, // 1-验收组长
      );
      
      if (leaderId > 0) {
        // 获取当前专家ID
        final currentExpertIdStr = expertId; // 从UserProfileMixin获取
        final currentExpertIdInt = int.tryParse(currentExpertIdStr) ?? 0;
        
        isLeader.value = (leaderId == currentExpertIdInt);
        debugPrint('✅ 验收评估详情页 - 验收组长ID: $leaderId, 当前专家ID: $currentExpertIdInt, 是否组长: ${isLeader.value}');
      } else {
        isLeader.value = false;
        debugPrint('ℹ️ 验收评估详情页 - 暂无验收组长');
      }
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 加载验收组长信息失败: $e');
      isLeader.value = false;
    }
  }

  /// 加载项目详细信息
  Future<void> loadProjectDetail() async {
    if (projectId == null) return;
    
    try {
      debugPrint('🔄 验收评估详情页 - 开始加载项目详细信息');
      isLoading.value = true;
      errorMessage.value = '';
      
      final projectDetail = await ProjectApi.getProjectInfo(projectId: projectId!);
      project.value = projectDetail;
      
      debugPrint('✅ 验收评估详情页 - 加载项目详细信息成功');
      debugPrint('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
      debugPrint('📋 项目详细信息：');
      debugPrint('  ├─ 项目ID: ${projectDetail.id}');
      debugPrint('  ├─ 项目名称: ${projectDetail.projectName ?? "未命名"}');
      debugPrint('  ├─ 项目编号: ${projectDetail.projectNo ?? "无"}');
      debugPrint('  ├─ 申报部门: ${projectDetail.declareDepartment ?? "无"}');
      debugPrint('  ├─ 预算金额: ${projectDetail.budgetAmount ?? "无"}万元');
      debugPrint('  ├─ 项目管理员: ${projectDetail.projectManager ?? "无"}');
      debugPrint('  ├─ 项目联系人: ${projectDetail.projectContact ?? "无"}');
      debugPrint('  ├─ 联系电话: ${projectDetail.phone ?? "无"}');
      debugPrint('  ├─ 申报时间: ${projectDetail.declareTime ?? "无"}');
      debugPrint('  └─ 🔴 项目当前状态: ${projectDetail.status} (${ProjectModel.getStatusTextByValue(projectDetail.status)})');
      debugPrint('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
      debugPrint('');
      debugPrint('⚠️ 重要提示：提交验收时将使用项目状态: ${projectDetail.status}');
      debugPrint('   - 此状态值将作为 projectStatus 参数传递给后端');
      debugPrint('   - 确保此状态与后端数据库中的项目状态一致');
      debugPrint('');
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 加载项目详细信息失败: $e');
      errorMessage.value = e.toString().replaceAll('Exception: ', '');
    } finally {
      isLoading.value = false;
    }
  }

  /// 加载项目专家列表
  Future<void> loadProjectExperts() async {
    if (projectId == null) return;
    
    try {
      debugPrint('👥 验收评估详情页 - 开始加载项目专家列表');
      isLoadingExperts.value = true;
      expertErrorMessage.value = '';
      
      // 验收评估页面显示验收人专家列表 (flag = 1)
      final experts = await ProjectApi.getProjectExpertList(
        projectId: projectId!,
        flag: 1, // 1-验收人专家列表
      );
      
      projectExperts.value = experts;
      debugPrint('✅ 验收评估详情页 - 加载项目专家列表成功，共 ${experts.length} 个专家');
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 加载项目专家列表失败: $e');
      expertErrorMessage.value = e.toString().replaceAll('Exception: ', '');
    } finally {
      isLoadingExperts.value = false;
    }
  }

  /// 刷新项目详细信息
  Future<void> refreshProjectDetail() async {
    await Future.wait([
      loadProjectDetail(),
      loadProjectExperts(),
      loadAcceptanceFiles(),
    ]);
  }

  /// 单独刷新专家列表
  Future<void> refreshProjectExperts() async {
    await loadProjectExperts();
  }
  
  /// 加载验收归档文件列表
  Future<void> loadAcceptanceFiles() async {
    if (projectId == null) return;
    
    try {
      debugPrint('📁 验收评估详情页 - 开始加载验收归档文件列表');
      isLoadingFiles.value = true;
      filesErrorMessage.value = '';
      
      // 获取验收归档文件（fileType = 6, supplierId = 0）
      final files = await ProjectApi.getProjectFiles(
        projectId: projectId!,
        supplierId: 0, // 验收归档文件不关联供应商
        fileType: 6, // 6-终验文件（验收归档资料）
      );
      
      acceptanceFiles.value = files;
      debugPrint('✅ 验收评估详情页 - 加载验收归档文件列表成功，共 ${files.length} 个文件');
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 加载验收归档文件列表失败: $e');
      filesErrorMessage.value = e.toString().replaceAll('Exception: ', '');
    } finally {
      isLoadingFiles.value = false;
    }
  }
  
  /// 刷新验收归档文件列表
  Future<void> refreshAcceptanceFiles() async {
    await loadAcceptanceFiles();
  }
  
  /// 下载验收归档文件
  Future<void> downloadAcceptanceFile(SupplierFileModel file) async {
    if (file.id == null) {
      LoadingUtil.error('文件ID无效');
      return;
    }
    
    final fileId = file.id!;
    
    // 检查是否已经在下载
    if (isDownloading[fileId] == true) {
      LoadingUtil.info('文件正在下载中，请稍候...');
      return;
    }
    
    try {
      debugPrint('📥 验收评估详情页 - 开始下载验收归档文件');
      debugPrint('  ├─ 文件ID: $fileId');
      debugPrint('  ├─ 文件名: ${file.fileName}');
      debugPrint('  ├─ 文件URL: ${file.filePath}');
      debugPrint('  └─ 文件大小: ${file.fileSizeReadable}');
      
      // 🔐 请求存储权限
      final permissionStatus = await _requestStoragePermission();
      if (!permissionStatus) {
        LoadingUtil.error('存储权限被拒绝，无法下载文件');
        return;
      }
      
      // 标记为正在下载
      isDownloading[fileId] = true;
      downloadProgress[fileId] = 0.0;
      
      // 获取下载目录
      Directory? downloadDir;
      if (Platform.isAndroid) {
        // Android: 使用应用的外部存储目录
        // Android 10+ 不允许直接访问公共Download目录
        downloadDir = await getExternalStorageDirectory();
        
        if (downloadDir != null) {
          // 在应用目录下创建Downloads子目录
          final appDownloadsDir = Directory('${downloadDir.path}/Downloads');
          if (!await appDownloadsDir.exists()) {
            await appDownloadsDir.create(recursive: true);
          }
          downloadDir = appDownloadsDir;
          
          debugPrint('📁 使用应用下载目录: ${downloadDir.path}');
        }
      } else if (Platform.isIOS) {
        // iOS: 使用应用文档目录
        downloadDir = await getApplicationDocumentsDirectory();
      } else {
        // 其他平台: 使用应用文档目录
        downloadDir = await getApplicationDocumentsDirectory();
      }
      
      if (downloadDir == null) {
        throw Exception('无法获取下载目录');
      }
      
      // 构建保存路径，如果文件已存在则添加后缀
      String fileName = file.fileName ?? 'download_${DateTime.now().millisecondsSinceEpoch}';
      String savePath = '${downloadDir.path}/$fileName';
      
      // 如果文件已存在，添加时间戳后缀
      if (await File(savePath).exists()) {
        final timestamp = DateTime.now().millisecondsSinceEpoch;
        final nameWithoutExt = fileName.contains('.') 
            ? fileName.substring(0, fileName.lastIndexOf('.'))
            : fileName;
        final ext = fileName.contains('.') 
            ? fileName.substring(fileName.lastIndexOf('.'))
            : '';
        fileName = '${nameWithoutExt}_$timestamp$ext';
        savePath = '${downloadDir.path}/$fileName';
      }
      
      debugPrint('💾 保存路径: $savePath');
      
      // 使用DioService下载文件
      final dioService = DioService.to;
      await dioService.downloadFile(
        file.filePath ?? '',
        savePath,
        onReceiveProgress: (received, total) {
          if (total > 0) {
            final progress = received / total;
            downloadProgress[fileId] = progress;
            debugPrint('📊 下载进度: ${(progress * 100).toStringAsFixed(1)}% ($received / $total bytes)');
          }
        },
      );
      
      debugPrint('✅ 文件下载成功: $savePath');
      
      // 下载完成
      downloadProgress[fileId] = 1.0;
      
      // 友好的成功提示
      final downloadedFileName = file.fileName ?? '文件';
      if (Platform.isAndroid) {
        LoadingUtil.success('文件下载成功！\n保存在：应用目录/Downloads/$downloadedFileName');
      } else {
        LoadingUtil.success('文件下载成功！');
      }
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 下载文件失败: $e');
      
      // 清除下载进度
      downloadProgress.remove(fileId);
      
      LoadingUtil.error(e.toString().replaceAll('Exception: ', ''));
    } finally {
      // 移除下载状态
      isDownloading.remove(fileId);
    }
  }

  /// 🔥 获取当前登录专家的ID（从UserProfileMixin）
  int get currentExpertId {
    final expertIdStr = expertId; // 从UserProfileMixin获取String类型的expertId
    final parsedId = int.tryParse(expertIdStr);
    
    if (parsedId == null || parsedId <= 0) {
      debugPrint('⚠️ 专家ID无效: $expertIdStr，使用默认值1');
      return 1; // 如果解析失败，使用默认值
    }
    
    debugPrint('✅ 使用专家ID: $parsedId');
    return parsedId;
  }

  /// 判断当前专家是否已完成验收
  bool get hasCompletedCheck {
    try {
      final currentId = currentExpertId;
      final experts = projectExperts;
      
      // 从专家列表中找到当前专家
      for (final expert in experts) {
        if (expert.expertId == currentId) {
          // checkStatus == 1 表示已验收
          return expert.checkStatus == 1;
        }
      }
      
      return false;
    } catch (e) {
      debugPrint('判断验收状态失败: $e');
      return false;
    }
  }

  /// 开始验收 - 显示验收底部弹出框
  void onStartCheck() {
    try {
      debugPrint('🚀 验收评估详情页 - 开始验收');
      
      if (project.value == null) {
        LoadingUtil.info('项目信息未加载完成，请稍后再试');
        return;
      }
      
      // 重置验收状态
      _resetCheckState();
      
      // 🔥 自动检测是否是最后一个专家（组长）
      _autoCheckLeaderStatus();
      
      // 显示验收底部弹出框
      _showCheckBottomSheet();
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 开始验收失败: $e');
      LoadingUtil.error('开始验收失败，请重试');
    }
  }

  /// 重置验收状态
  void _resetCheckState() {
    checkOpinion.value = '';
    signatureController.clear();
    hasSignature.value = false;
    signatureUploaded.value = false;
    isUploading.value = false;
    uploadErrorMessage.value = '';
    isLeader.value = false;
    isCheckingLastExpert.value = false;
  }
  
  /// 自动检测组长状态（静默检测，不显示toast）
  /// 在打开验收弹出框时自动调用，使用投票选举结果判断组长身份
  Future<void> _autoCheckLeaderStatus() async {
    if (projectId == null) return;
    
    try {
      isCheckingLastExpert.value = true;
      
      debugPrint('🔍 自动检测：开始检查是否是验收组长（基于投票选举结果）');
      
      // 获取验收组长ID (voteFlag=1表示验收组长)
      final leaderId = await UserApi.getMostVotesExpertId(
        projectId: projectId!,
        voteFlag: 1, // 1-验收组长
      );
      
      if (leaderId > 0) {
        // 获取当前专家ID
        final currentExpertIdStr = expertId; // 从UserProfileMixin获取
        final currentExpertIdInt = int.tryParse(currentExpertIdStr) ?? 0;
        
        if (leaderId == currentExpertIdInt) {
          // 是验收组长，自动勾选
        isLeader.value = true;
          debugPrint('✅ 自动检测：当前专家是验收组长，已自动勾选');
      } else {
          // 不是验收组长
        isLeader.value = false;
          debugPrint('ℹ️ 自动检测：当前专家不是验收组长');
        }
      } else {
        // 还未选出组长
        isLeader.value = false;
        debugPrint('ℹ️ 自动检测：暂未选出验收组长');
      }
      
    } catch (e) {
      debugPrint('⚠️ 自动检测组长状态失败: $e');
      isLeader.value = false;
    } finally {
      isCheckingLastExpert.value = false;
    }
  }

  /// 显示验收底部弹出框
  void _showCheckBottomSheet() {
    Get.bottomSheet(
      _CheckBottomSheet(controller: this),
      isScrollControlled: true,
      isDismissible: true,
      enableDrag: true,
    );
  }

  /// 清除手写签名
  void onClearSignature() {
    try {
      debugPrint('🗑️ 验收评估详情页 - 清除手写签名');
      signatureController.clear();
      hasSignature.value = false;
      signatureUploaded.value = false; // 清除签名时也清除上传状态
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 清除签名异常: $e');
    }
  }

  /// 将签名转换为图片文件
  Future<File?> _convertSignatureToImageFile() async {
    try {
      debugPrint('🖼️ 验收评估详情页 - 开始转换签名为图片');
      
      if (signatureController.isEmpty) {
        debugPrint('⚠️ 签名为空，无法转换');
        return null;
      }
      
      // 获取签名的图片数据
      final Uint8List? signatureBytes = await signatureController.toPngBytes();
      if (signatureBytes == null) {
        debugPrint('❌ 签名转换失败');
        return null;
      }
      
      // 创建临时文件
      final String timestamp = DateTime.now().millisecondsSinceEpoch.toString();
      final String fileName = 'signature_$timestamp.png';
      
      // 使用系统临时目录
      final String tempPath = Directory.systemTemp.path;
      final String filePath = '$tempPath/$fileName';
      
      // 写入文件
      final File signatureFile = File(filePath);
      await signatureFile.writeAsBytes(signatureBytes);
      
      debugPrint('✅ 签名转换成功: $filePath');
      debugPrint('📄 文件大小: ${signatureBytes.length} bytes');
      
      return signatureFile;
      
    } catch (e) {
      debugPrint('❌ 签名转换异常: $e');
      return null;
    }
  }

  /// 上传签名图片（内部方法，由验收通过/拒绝调用）
  /// [reviewStatus] 验收状态：1-未通过，2-通过
  Future<bool> _uploadSignatureWithStatus(int reviewStatus) async {
    try {
      debugPrint('📷 验收评估详情页 - 开始上传签名，reviewStatus=$reviewStatus');
      
      if (!hasSignature.value || signatureController.isEmpty) {
        LoadingUtil.info('请先完成手写签名');
        return false;
      }
      
      debugPrint('🔄 验收评估详情页 - 开始转换并上传签名');
      
      // 将签名转换为图片文件
      final signatureFile = await _convertSignatureToImageFile();
      if (signatureFile == null) {
        uploadErrorMessage.value = '签名转换失败，请重新签名';
        LoadingUtil.error('签名转换失败，请重新签名');
        return false;
      }
      
      // 调用上传签名API（上传图片并提交验收状态）
      // flag=1 表示验收人
      final uploadResult = await ProjectApi.uploadSignature(
        expertId: currentExpertId,
        projectId: projectId!,
        flag: 1, // 1-验收人签名
        file: signatureFile,
        reviewStatus: reviewStatus, // 传递验收状态
      );
        
        // 清理临时文件
        try {
          await signatureFile.delete();
          debugPrint('🗑️ 临时签名文件已清理');
        } catch (e) {
          debugPrint('⚠️ 清理临时文件失败: $e');
        }
        
      if (uploadResult.success) {
        debugPrint('✅ 验收评估详情页 - 签名上传成功: ${uploadResult.url}');
        signatureUploaded.value = true;
        return true;
      } else {
        debugPrint('❌ 验收评估详情页 - 签名上传失败: ${uploadResult.errorMessage}');
        uploadErrorMessage.value = uploadResult.errorMessage ?? '上传失败';
        LoadingUtil.error(uploadResult.errorMessage ?? '签名上传失败，请重试');
        return false;
      }
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 上传签名异常: $e');
      uploadErrorMessage.value = '网络错误，请重试';
      LoadingUtil.error('签名上传失败，请检查网络后重试');
      return false;
    }
  }

  /// 取消验收 - 关闭弹出框
  void onCancelCheck() {
    debugPrint('❌ 验收评估详情页 - 取消验收');
    Get.back();
  }

  /// 验证是否可以提交验收
  bool canSubmitCheck() {
    // 🔥 区分组长和组员的验证逻辑
    
    // 组长：需要填写验收意见 + 签名
    if (isLeader.value) {
    // 验证验收意见
    if (checkOpinion.value.trim().isEmpty) {
      LoadingUtil.info('请填写验收意见');
      return false;
    }
    }
    // 组员：只需要签名（验收意见由组长统一填写）
    
    // 验证签名是否已绘制（不再要求提前上传）
    if (!hasSignature.value || signatureController.isEmpty) {
      LoadingUtil.info('请先完成手写签名');
      return false;
    }
    
    if (projectId == null) {
      LoadingUtil.info('项目ID为空');
      return false;
    }
    
    return true;
  }

  /// 验收通过
  Future<void> onCheckApprove() async {
    try {
      debugPrint('✅ 验收评估详情页 - 验收通过');
      
      // 验证是否可以提交
      if (!canSubmitCheck()) {
        return;
      }
      
      // 检查项目信息是否存在
      if (project.value == null) {
        LoadingUtil.info('项目信息未加载，无法提交');
        return;
      }
      
      // 显示加载提示
      LoadingUtil.show('正在提交验收结果...');
      
      // 🔥 第一步：上传签名图片（传递reviewStatus=2表示通过）
      debugPrint('📷 第一步：上传签名图片');
      final uploadSuccess = await _uploadSignatureWithStatus(2); // 2-通过
      if (!uploadSuccess) {
        EasyLoading.dismiss();
        return;
      }
      
      // 打印详细参数
      final isLeaderValue = isLeader.value ? 1 : 0;
      final currentProjectStatus = project.value!.status ?? 11; // 使用项目实际状态，默认11(初验申请)
      
      debugPrint('📝 第二步：调用 expertReview API - 验收通过');
      debugPrint('📝 专家ID: $currentExpertId');
      debugPrint('📝 项目ID: $projectId');
      debugPrint('📝 项目当前状态: $currentProjectStatus (从项目信息获取)');
      debugPrint('📝 验收状态 reviewStatus: 2 (通过)');
      debugPrint('📝 验收意见 note: ${checkOpinion.value.trim()}');
      debugPrint('📝 是否组长 isLeader: $isLeaderValue');
      
      // 🔥 第二步：调用专家评审/验收API - 验收通过
      final success = await UserApi.expertReview(
        expertId: currentExpertId,
        projectId: projectId!,
        projectStatus: currentProjectStatus, // 使用项目实际状态
        reviewStatus: 2, // 2-通过
        note: checkOpinion.value.trim(), // 使用填写的验收意见
        isLeader: isLeaderValue, // 使用用户选择的组长状态
      );
      
      if (success) {
        debugPrint('✅ 验收评估详情页 - 验收通过处理完成');
        
        // 🔥 关键修复：先关闭加载框，再关闭底部弹出框
        EasyLoading.dismiss();
        debugPrint('🔄 加载框已关闭');
        
        // 稍微延迟确保加载框完全消失
        await Future.delayed(const Duration(milliseconds: 100));
        
        // 关闭底部弹出框
        Get.back();
        debugPrint('🚪 验收弹出框已关闭');
        
        // 稍微延迟一下再刷新数据，确保弹出框完全关闭
        await Future.delayed(const Duration(milliseconds: 300));
        
        // 刷新项目信息和专家列表
        await refreshProjectDetail();
        
        // 显示成功提示
        LoadingUtil.success('项目验收已通过');
      }
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 验收通过失败: $e');
      LoadingUtil.error('验收通过操作失败：${e.toString().replaceAll('Exception: ', '')}');
    }
  }

  /// 验收拒绝
  Future<void> onCheckReject() async {
    try {
      debugPrint('❌ 验收评估详情页 - 验收拒绝');
      
      // 验证是否可以提交
      if (!canSubmitCheck()) {
        return;
      }
      
      // 检查项目信息是否存在
      if (project.value == null) {
        LoadingUtil.info('项目信息未加载，无法提交');
        return;
      }
      
      // 显示加载提示
      LoadingUtil.show('正在提交验收结果...');
      
      // 🔥 第一步：上传签名图片（传递reviewStatus=1表示未通过）
      debugPrint('📷 第一步：上传签名图片');
      final uploadSuccess = await _uploadSignatureWithStatus(1); // 1-未通过
      if (!uploadSuccess) {
        EasyLoading.dismiss();
        return;
      }
      
      // 打印详细参数
      final isLeaderValue = isLeader.value ? 1 : 0;
      final currentProjectStatus = project.value!.status ?? 11; // 使用项目实际状态，默认11(初验申请)
      
      debugPrint('📝 第二步：调用 expertReview API - 验收拒绝');
      debugPrint('📝 专家ID: $currentExpertId');
      debugPrint('📝 项目ID: $projectId');
      debugPrint('📝 项目当前状态: $currentProjectStatus (从项目信息获取)');
      debugPrint('📝 验收状态 reviewStatus: 1 (未通过)');
      debugPrint('📝 验收意见 note: ${checkOpinion.value.trim()}');
      debugPrint('📝 是否组长 isLeader: $isLeaderValue');
      
      // 🔥 第二步：调用专家评审/验收API - 验收拒绝
      final success = await UserApi.expertReview(
        expertId: currentExpertId,
        projectId: projectId!,
        projectStatus: currentProjectStatus, // 使用项目实际状态
        reviewStatus: 1, // 1-未通过
        note: checkOpinion.value.trim(), // 使用填写的验收意见
        isLeader: isLeaderValue, // 使用用户选择的组长状态
      );
      
      if (success) {
        debugPrint('✅ 验收评估详情页 - 验收拒绝处理完成');
        
        // 🔥 关键修复：先关闭加载框，再关闭底部弹出框
        EasyLoading.dismiss();
        debugPrint('🔄 加载框已关闭');
        
        // 稍微延迟确保加载框完全消失
        await Future.delayed(const Duration(milliseconds: 100));
        
        // 关闭底部弹出框
        Get.back();
        debugPrint('🚪 验收弹出框已关闭');
        
        // 稍微延迟一下再刷新数据，确保弹出框完全关闭
        await Future.delayed(const Duration(milliseconds: 300));
        
        // 刷新项目信息和专家列表
        await refreshProjectDetail();
        
        // 显示提示
        LoadingUtil.success('项目验收已拒绝');
      }
      
    } catch (e) {
      debugPrint('❌ 验收评估详情页 - 验收拒绝失败: $e');
      LoadingUtil.error('验收拒绝操作失败：${e.toString().replaceAll('Exception: ', '')}');
    }
  }

  /// 请求存储权限
  Future<bool> _requestStoragePermission() async {
    try {
      debugPrint('🔐 开始请求存储权限');
      
      // Android 10+ 使用新的权限模型
      if (Platform.isAndroid) {
        // 请求管理外部存储权限
        var status = await Permission.storage.status;
        
        debugPrint('🔐 当前存储权限状态: $status');
        
        if (status.isGranted) {
          debugPrint('✅ 存储权限已授予');
          return true;
        }
        
        if (status.isDenied) {
          debugPrint('⚠️ 存储权限被拒绝，请求权限...');
          status = await Permission.storage.request();
        }
        
        if (status.isPermanentlyDenied) {
          debugPrint('❌ 存储权限被永久拒绝，引导用户到设置页面');
          
          // 显示对话框引导用户到设置
          await Get.dialog(
            AlertDialog(
              title: const Text('需要存储权限'),
              content: const Text('下载文件需要访问存储空间。请在设置中开启存储权限。'),
              actions: [
                TextButton(
                  onPressed: () => Get.back(),
                  child: const Text('取消'),
                ),
                TextButton(
                  onPressed: () {
                    Get.back();
                    openAppSettings();
                  },
                  child: const Text('去设置'),
                ),
              ],
            ),
          );
          
          return false;
        }
        
        if (status.isGranted) {
          debugPrint('✅ 存储权限已授予');
          return true;
        }
        
        debugPrint('❌ 存储权限请求失败: $status');
        return false;
      }
      
      // iOS不需要额外权限来访问应用文档目录
      return true;
      
    } catch (e) {
      debugPrint('❌ 请求存储权限异常: $e');
      return false;
    }
  }

  void onTap() {}

  @override
  void onReady() {
    super.onReady();
    _initData();
  }

  @override
  void onClose() {
    // 先关闭所有可能打开的底部弹出框
    try {
      if (Get.isBottomSheetOpen == true) {
        Get.back();
        debugPrint('🚪 关闭底部弹出框');
      }
    } catch (e) {
      debugPrint('⚠️ 关闭底部弹出框失败: $e');
    }
    
    // 释放签名控制器资源
    signatureController.dispose();
    super.onClose();
  }
}

/// 验收底部弹出框组件
class _CheckBottomSheet extends StatelessWidget {
  final YanshouAssessmentDetialController controller;
  
  const _CheckBottomSheet({
    required this.controller,
  });

  @override
  Widget build(BuildContext context) {
    return Container(
      constraints: BoxConstraints(
        maxHeight: MediaQuery.of(context).size.height * 0.85,
      ),
      decoration: const BoxDecoration(
        color: Colors.white,
        borderRadius: BorderRadius.only(
          topLeft: Radius.circular(20),
          topRight: Radius.circular(20),
        ),
      ),
      child: Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          // 顶部指示器和标题
          _buildHeader(),
          
          // 内容区域
          Flexible(
            child: SingleChildScrollView(
              padding: const EdgeInsets.symmetric(horizontal: 20),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  // 项目信息
                  _buildProjectInfo(),
                  const SizedBox(height: 16),
                  
                  // 验收意见输入框
                  _buildCheckOpinionInput(),
                  const SizedBox(height: 16),
                  
                  // 签名图片上传
                  _buildSignatureUpload(),
                  const SizedBox(height: 16),
                  
                  // 错误信息显示
                  _buildErrorMessage(),
                  const SizedBox(height: 20),
                ],
              ),
            ),
          ),
          
          // 底部按钮
          _buildBottomButtons(),
        ],
      ),
    );
  }

  /// 构建头部
  Widget _buildHeader() {
    return Container(
      padding: const EdgeInsets.only(top: 8, bottom: 12),
      child: Column(
        children: [
          // 顶部指示器
          Container(
            width: 40,
            height: 4,
            decoration: BoxDecoration(
              color: Colors.grey.shade300,
              borderRadius: BorderRadius.circular(2),
            ),
          ),
          const SizedBox(height: 12),
          
          // 标题和关闭按钮
          Padding(
            padding: const EdgeInsets.symmetric(horizontal: 16),
            child: Row(
              children: [
                const Expanded(
                  child: Text(
                    '填写验收意见和签名',
                    style: TextStyle(
                      fontSize: 18,
                      fontWeight: FontWeight.bold,
                      color: Colors.black87,
                    ),
                  ),
                ),
                IconButton(
                  icon: Icon(Icons.close, size: 24, color: Colors.grey.shade600),
                  onPressed: () => Get.back(),
                  padding: EdgeInsets.zero,
                  constraints: const BoxConstraints(),
                  tooltip: '关闭',
                ),
              ],
            ),
          ),
        ],
      ),
    );
  }

  /// 构建项目信息
  Widget _buildProjectInfo() {
    return Obx(() {
      final project = controller.project.value;
      if (project == null) return const SizedBox.shrink();
      
      return Container(
        padding: const EdgeInsets.all(12),
        decoration: BoxDecoration(
          color: const Color(0xFFFFF5F5),  // 淡红色背景
          borderRadius: BorderRadius.circular(YanshouTheme.radiusMd),
          border: Border.all(
            color: const Color(0xFFFF6B6B).withOpacity(0.3),
          ),
        ),
        child: Row(
          children: [
            Container(
              padding: const EdgeInsets.all(4),
              decoration: BoxDecoration(
                gradient: YanshouTheme.primaryGradient,
                borderRadius: BorderRadius.circular(YanshouTheme.radiusSm),
              ),
              child: const Icon(
                Icons.assignment_outlined,
                color: Colors.white,
                size: 16,
              ),
            ),
            const SizedBox(width: 10),
            Expanded(
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text(
                    project.projectName ?? '未知项目',
                    style: YanshouTheme.subtitleStyle.copyWith(
                      fontSize: YanshouTheme.textMd,
                    ),
                    maxLines: 2,
                    overflow: TextOverflow.ellipsis,
                  ),
                  if (project.declareDepartment?.isNotEmpty == true && project.declareDepartment != 'null') ...[
                    const SizedBox(height: 2),
                    Text(
                      project.declareDepartment!,
                      style: YanshouTheme.captionStyle,
                    ),
                  ],
                ],
              ),
            ),
          ],
        ),
      );
    });
  }

  /// 构建验收意见输入框
  Widget _buildCheckOpinionInput() {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        const Text(
          '验收意见 *',
          style: TextStyle(
            fontSize: 16,
            fontWeight: FontWeight.w500,
            color: Colors.black87,
          ),
        ),
        const SizedBox(height: 8),
        Container(
          decoration: BoxDecoration(
            borderRadius: BorderRadius.circular(8),
            border: Border.all(color: Colors.grey.shade300),
          ),
          child: TextField(
            maxLines: 4,
            onChanged: (value) => controller.checkOpinion.value = value,
            decoration: InputDecoration(
              hintText: '请填写详细的验收意见...',
              hintStyle: TextStyle(color: Colors.grey.shade500),
              border: InputBorder.none,
              contentPadding: const EdgeInsets.all(12),
            ),
            style: const TextStyle(fontSize: 14),
          ),
        ),
      ],
    );
  }

  /// 构建手写签名
  Widget _buildSignatureUpload() {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Row(
          children: [
            const Text(
              '专家签名 *',
              style: TextStyle(
                fontSize: 16,
                fontWeight: FontWeight.w500,
                color: Colors.black87,
              ),
            ),
            const Spacer(),
            Obx(() {
              return controller.hasSignature.value
                  ? TextButton.icon(
                      onPressed: controller.onClearSignature,
                      icon: const Icon(Icons.clear, size: 16),
                      label: const Text('清除'),
                      style: TextButton.styleFrom(
                        foregroundColor: Colors.red.shade600,
                        padding: const EdgeInsets.symmetric(horizontal: 8),
                      ),
                    )
                  : const SizedBox.shrink();
            }),
          ],
        ),
        const SizedBox(height: 8),
        
        // 手写签名板
        Container(
          width: double.infinity,
          height: 150,
          decoration: BoxDecoration(
            borderRadius: BorderRadius.circular(8),
            border: Border.all(color: Colors.grey.shade300),
            color: Colors.white,
          ),
          child: ClipRRect(
            borderRadius: BorderRadius.circular(8),
            child: Signature(
              controller: controller.signatureController,
              backgroundColor: Colors.white,
            ),
          ),
        ),
        
        const SizedBox(height: 8),
        
        // 签名状态提示
        Obx(() {
          final hasSignature = controller.hasSignature.value;
          if (hasSignature) {
            return Container(
              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
              decoration: BoxDecoration(
                color: Colors.blue.shade50,
                borderRadius: BorderRadius.circular(8),
                border: Border.all(color: Colors.blue.shade200),
              ),
              child: Row(
                children: [
                  Icon(Icons.check_circle_outline, color: Colors.blue.shade700, size: 18),
                  const SizedBox(width: 8),
                  Text(
                    '签名已完成，请选择验收结果提交',
                    style: TextStyle(
                      color: Colors.blue.shade700,
                      fontSize: 13,
                      fontWeight: FontWeight.w500,
                    ),
                  ),
                ],
              ),
            );
          } else {
            return Container(
              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
              decoration: BoxDecoration(
                color: Colors.grey.shade100,
                borderRadius: BorderRadius.circular(8),
                border: Border.all(color: Colors.grey.shade300),
                    ),
              child: Row(
                children: [
                  Icon(Icons.info_outline, color: Colors.grey.shade600, size: 18),
                  const SizedBox(width: 8),
                  Text(
                    '请在上方签名板中完成手写签名',
                    style: TextStyle(
                      color: Colors.grey.shade600,
                      fontSize: 13,
                    ),
                  ),
                ],
              ),
            );
          }
        }),
      ],
    );
  }

  /// 构建错误信息
  Widget _buildErrorMessage() {
    return Obx(() {
      final errorMessage = controller.uploadErrorMessage.value;
      if (errorMessage.isEmpty) return const SizedBox.shrink();
      
      return Container(
        padding: const EdgeInsets.all(12),
        decoration: BoxDecoration(
          color: Colors.red.shade50,
          borderRadius: BorderRadius.circular(8),
          border: Border.all(color: Colors.red.shade200),
        ),
        child: Row(
          children: [
            Icon(Icons.error_outline, color: Colors.red.shade600, size: 16),
            const SizedBox(width: 8),
            Expanded(
              child: Text(
                errorMessage,
                style: TextStyle(
                  color: Colors.red.shade600,
                  fontSize: 12,
                ),
              ),
            ),
          ],
        ),
      );
    });
  }

  /// 构建底部按钮
  Widget _buildBottomButtons() {
    return Container(
      padding: const EdgeInsets.all(20),
      decoration: BoxDecoration(
        color: Colors.white,
        boxShadow: [
          BoxShadow(
            color: Colors.grey.shade200,
            offset: const Offset(0, -2),
            blurRadius: 8,
            spreadRadius: 0,
          ),
        ],
      ),
      child: SafeArea(
        child: Row(
          children: [
            // 验收拒绝按钮（仅组长可见）
            Obx(() {
              if (!controller.isLeader.value) {
                return const SizedBox.shrink();
              }
              
              return Expanded(
              child: Obx(() {
                final hasOpinion = controller.checkOpinion.value.trim().isNotEmpty;
                  final hasSignature = controller.hasSignature.value;
                  final canSubmit = hasOpinion && hasSignature;
                
                return Container(
                  height: 44,
                  decoration: BoxDecoration(
                    color: Colors.white,
                    border: Border.all(
                      color: canSubmit 
                          ? const Color(0xFFFF6B6B) 
                          : YanshouTheme.dividerColor,
                      width: 1.5,
                    ),
                    borderRadius: BorderRadius.circular(YanshouTheme.radiusXl),
                  ),
                  child: OutlinedButton.icon(
                    onPressed: canSubmit ? controller.onCheckReject : null,
                    icon: const Icon(Icons.close_rounded, size: 18),
                    label: const Text('验收拒绝'),
                    style: OutlinedButton.styleFrom(
                      padding: EdgeInsets.zero,
                      side: BorderSide.none,
                      foregroundColor: const Color(0xFFFF6B6B),
                      disabledForegroundColor: YanshouTheme.textHint,
                      shape: RoundedRectangleBorder(
                        borderRadius: BorderRadius.circular(YanshouTheme.radiusXl),
                      ),
                    ),
                  ),
                );
              }),
              );
            }),
            
            Obx(() {
              if (controller.isLeader.value) {
                return const SizedBox(width: 12);
              } else {
                return const SizedBox.shrink();
              }
            }),
            
            // 验收通过按钮（仅组长可见）/ 提交验收按钮（非组长）
            Expanded(
              child: Obx(() {
                final isLeader = controller.isLeader.value;
                final hasOpinion = controller.checkOpinion.value.trim().isNotEmpty;
                final hasSignature = controller.hasSignature.value;
                final canSubmit = isLeader ? (hasOpinion && hasSignature) : hasSignature;
                
                return Container(
                  height: 44,
                  decoration: canSubmit
                      ? (isLeader ? YanshouTheme.successButtonDecoration : YanshouTheme.primaryButtonDecoration)
                      : BoxDecoration(
                          color: YanshouTheme.dividerColor,
                          borderRadius: BorderRadius.circular(YanshouTheme.radiusXl),
                        ),
                  child: ElevatedButton.icon(
                    onPressed: canSubmit ? controller.onCheckApprove : null,
                    icon: Icon(isLeader ? Icons.check_rounded : Icons.send_rounded, size: 18),
                    label: Text(isLeader ? '验收通过' : '提交验收'),
                    style: ElevatedButton.styleFrom(
                      padding: EdgeInsets.zero,
                      backgroundColor: Colors.transparent,
                      foregroundColor: Colors.white,
                      shadowColor: Colors.transparent,
                      elevation: 0,
                      disabledBackgroundColor: Colors.transparent,
                      disabledForegroundColor: YanshouTheme.textHint,
                      shape: RoundedRectangleBorder(
                        borderRadius: BorderRadius.circular(YanshouTheme.radiusXl),
                      ),
                    ),
                  ),
                );
              }),
            ),
          ],
        ),
      ),
    );
  }
}
